from camel.toolkits import FunctionTool

def my_weird_add(a: int, b: int) -> int:
    r"""Adds two numbers.
    Args:
        a (int): The first number to be added.
        b (int): The second number to be added.
    Returns:
        integer: The sum of the two numbers.
    """
    return a + b + 7

agent = ChatAgent(
    tools=[FunctionTool(my_weird_add)]
)

response = agent.step("What is 15+15")
print(response.msgs[0].content)

import asyncio
from camel.toolkits.mcp_toolkit import MCPToolkit, MCPClient

async def run_time_example():
    # Initialize the MCPToolkit with your configuration file
    mcp_toolkit = MCPToolkit(config_path="config/time.json")
    # Connect to all configured MCP servers
    await mcp_toolkit.connect()
    camel_agent = ChatAgent(
        model=model,
        tools=[*mcp_toolkit.get_tools()],
    )
    response = await camel_agent.astep("What time is it now?")
    print(response.msgs[0].content)
    print(response.info['tool_calls'])
    # Disconnect from all servers
    await mcp_toolkit.disconnect()
await run_time_example()

# arxiv_toolkit_server.py
import argparse
import sys
from camel.toolkits import ArxivToolkit
if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Run Arxiv Toolkit with MCP server mode.",
        usage=f"python {sys.argv[0]} [--mode MODE]",
    )
    parser.add_argument(
        "--mode",
        choices=["stdio", "sse"],
        default="stdio",
        help="MCP server mode (default: 'stdio')",
    )
    parser.add_argument(
        "--timeout",
        type=float,
        default=None,
        help="Timeout for the MCP server (default: None)",
    )
    args = parser.parse_args()
    toolkit = ArxivToolkit(timeout=args.timeout)
    # Run the toolkit as an MCP server
    toolkit.mcp.run(args.mode)

search_toolkit = PulseMCPSearchToolkit()
search_toolkit.search_mcp_servers(
    query="Slack",
    package_registry="npm",  # Only search for servers registered in npm
    top_k=1,
)

from camel.agents import MCPAgent, MCPRegistryConfig, MCPRegistryType 
smithery_config = MCPRegistryConfig(
  type=MCPRegistryType.SMITHERY, 
  api_key=os.getenv("SMITHERY_API_KEY")
)

# Create MCPAgent with registry configurations
agent = MCPAgent(
  model=model,registry_configs=[smithery_config]
)

async with agent:
    response = await agent.astep(message)
    print(f"\nResponse from {message}:")
    print(response.msgs[0].content)

"""
Response from What MCP tools I can use for connecting to the Gmail?:
 I found several MCP tools that can connect to Gmail. Here are the options:
 1. **Google Workspace Server** (@rishipradeep-think41/gsuite-mcp)
    - Manage emails and calendar events through Gmail and Calendar APIs
    - [Configure here](https://smithery.ai/server/@rishipradeep-think41/gsuite-mcp/config)
 2. **VeyraX MCP** (@VeyraX/veyrax-mcp)
    - Connects to 70+ tools including Gmail and Calendar
    - [Configure here](https://smithery.ai/server/@VeyraX/veyrax-mcp/config)
 3. **Google Workspace MCP Server** (google-workspace-server)
    - Interact with Gmail and Calendar APIs
    - [Configure here](https://smithery.ai/server/google-workspace-server/config)
 4. **Headless Gmail Server** (@baryhuang/mcp-headless-gmail)
    - Access and send emails through Gmail without local credential setup
    - [Configure here](https://smithery.ai/server/@baryhuang/mcp-headless-gmail/config)
 5. **Google Workspace Server** (@rishipradeep-think41/gmail-backupmcp)
    - Another option for managing Gmail and Calendar
 Each of these tools requires configuration before it can be used. You'll need 
 to click on one of the configuration links above to set up the tool with your 
 Gmail credentials. Once you've completed the configuration, let me know which 
 tool you've chosen, and I can help you use it to connect to your Gmail account.
"""

"""
Response from Use Brave MCP search tools to search info about Camel-AI.org.:
 # CAMEL-AI.org: Information and Purpose
 Based on my search results, here's what I found about CAMEL-AI.org:
 ## Organization Overview
 CAMEL-AI.org is the first LLM (Large Language Model) multi-agent framework and 
 an open-source community. The name CAMEL stands for "Communicative Agents for 
 Mind Exploration of Large Language Model Society."
 ## Core Purpose
 The organization is dedicated to "Finding the Scaling Law of Agents" - this 
 appears to be their primary research mission, focusing on understanding how 
 agent-based AI systems scale and develop.
 ## Research Focus
 CAMEL-AI is a research-driven organization that explores:
 - Scalable techniques for autonomous cooperation among communicative agents
 - Multi-agent frameworks for AI systems
 - Data generation for AI training
 - AI society simulations
 ## Community and Collaboration
 - They maintain an active open-source community
 - They invite contributors and collaborators through platforms like Slack and 
 Discord
 - The organization has a research collaboration questionnaire for those 
 interested in building or researching environments for LLM-based agents
 ## Technical Resources
 - Their code is available on GitHub (github.com/camel-ai) with 18 repositories
 - They provide documentation for developers and researchers at 
 docs.camel-ai.org
 - They offer tools and cookbooks for working with their agent framework
 ## Website and Online Presence
 - Main website: https://www.camel-ai.org/
 - GitHub: https://github.com/camel-ai
 - Documentation: https://docs.camel-ai.org/
 The organization appears to be at the forefront of research on multi-agent AI 
 systems, focusing on how these systems can cooperate autonomously and scale 
 effectively.
"""

# Create a default chat agent - customize as needed
chat_agent = ChatAgent()
chat_agent_description = "The general agent is a helpful assistant that can answer questions and help with tasks."

reasoning_agent = ChatAgent(
    model=ModelFactory.create(
        model_platform=ModelPlatformType.OPENAI,
        model_type="gpt-4o-mini",
    )
)
reasoning_agent_description = "The reasoning agent is a helpful assistant that can reason about the world."

# Create another agent for searching the web
search_agent = ChatAgent(
    model=ModelFactory.create(
        model_platform=ModelPlatformType.OPENAI,
        model_type="gpt-4o",
    ),
    tools=[FunctionTool(SearchToolkit().search_brave)],
)
search_agent_description = "The search agent is a helpful assistant that can search the web."

# Provide a list of agents with names
agents_dict = {
    "general": chat_agent,
    "search": search_agent,
    "reasoning": reasoning_agent,
}

# Provide descriptions for each agent
description_dict = {
    "general": chat_agent_description,
    "search": search_agent_description,
    "reasoning": reasoning_agent_description,
}